home *** CD-ROM | disk | FTP | other *** search
/ PC Media 23 / PC MEDIA CD23.iso / share / prog / anubis / e_s.h < prev    next >
Encoding:
C/C++ Source or Header  |  1995-08-04  |  8.3 KB  |  215 lines
  1. // E_S.H
  2. // (C) Anubis Software Enero 1995
  3. // Esta librería proporciona una ayuda con la E/S del sistema
  4. // está sacada del libro "Lenguaje C Biblioteca de Funciones"
  5.  
  6. // -----------------------------------------+
  7. // Inclusion de librerías de Borland C++    |
  8. // -----------------------------------------+
  9. #include <conio.h>
  10.  
  11. // -----------------------------------------+
  12. // Implementación de las funciones          |
  13. // -----------------------------------------+
  14.  
  15. /* NOMBRE: leer_car()
  16.  * FUNCION: Lee un carácter introducido por el teclado
  17.  *          y suprime el contenido del buffer E/S. Si su
  18.  *          rutina pide 2 caracteres en una fila con
  19.  *          getchar(), el segundo carácter retornado es el retorno
  20.  *          de carro para la primera entrada. Por ejemplo:
  21.  *
  22.  *          x=getchar();
  23.  *          y=getchar();
  24.  *
  25.  *          se asigna x al carácter introducido, no obstante
  26.  *          el retorno de carro está todavía en el buffer de entrada
  27.  *          y se asigna a y. leer_car() destruye el
  28.  *          contenido del buffer de entrada antes de volver.
  29.  *
  30.  *          Si EOF ocurre, leer_car() retorna el valor EOF.
  31.  */
  32. leer_car ()
  33. {
  34.    int letra;   /* letra que se devuelve a la rutina que llama */
  35.    int buffer;  /* los datos que permanecen en el buffer de entrada 
  36.                    se leen en el buffer */
  37.    letra = getchar();    /* obtener la respuesta */
  38.    buffer = letra;
  39.    */ obtener caracteres hasta que el buffer de entrada está vacio */
  40.    while( buffer != EOL && buffer != EOF)
  41.       buffer = getchar();
  42.    return ((buffer != EOF) ? letra : EOF);
  43. }// end leer_car
  44.  
  45.  
  46. /* NOMBRE: escribirln (cadena)
  47.  * FUNCION: Escribe la cadena en la salida estándar asegurando que solamente se
  48.  *          escribe un carácter de nueva linea. Si se lee una línea de un fichero,
  49.  *          no tenemos forma de saber si contiene o no un carácter de nueva línea.
  50.  *          Si suponemos que lo hace y no están presentes, la salida consistirá en
  51.  *          una línea. Si suponemos que no lo hace y lo hace, cada línea es a
  52.  *          doble espacio.
  53.  *          escribirln() elimina este problema.
  54.  */
  55. escribirln (char *cadena)
  56. {
  57.    while( *cadena != EOL && *cadena != NULL)
  58.       putchar( *cadena++);
  59.    putchar(NUEVALINEA);
  60. }// end escribirln
  61.  
  62.  
  63. /* NOMBRE: escribir_consola (cadena)
  64.  * FUNCION: Escribe la cadena en la consola asegurando que no se escribe un
  65.  *          carácter de nueva linea. La mayoría de los compiladores proporcionan
  66.  *          algunas definiciones para consola de E/S que están colocadas
  67.  *          normalmente en el fichero conio.h ( consola E/S). El identificador
  68.  *          imprimir_car ha sido definido en el fichero defn.h para la correcta
  69.  *          rutina de E/S de consola.
  70.  */
  71. escribir_consola(char * cadena)
  72. {
  73.    while (*cadena != EOL && *cadena != NULL)
  74.       imprimir_car(*cadena++);  /* ver defn.h para la definición */
  75.                                 /* de imprimir_car() */
  76. }// end escribir_consola
  77.  
  78.  
  79. /* NOMBRE: fescribir (puntero_fichero, cadena)
  80.  * FUNCION: Escribe la cadena en el fichero especificado con puntero_fichero
  81.  *          asegurando que una nueva línea de caracteres no se escribe.
  82.  */
  83. fescribir (FILE *puntero_fichero, char *cadena)
  84. {
  85.    while (*cadena != EOL && *cadena != NULL)
  86.       putc(*cadena++, puntero_fichero);
  87. }// end fescribir
  88.  
  89.  
  90. /* NOMBRE: fescribirln (puntero_fichero, cadena)
  91.  * FUNCION: escribe la cadena en el fichero referenciado por puntero_fichero
  92.  *          asegurando que solamente se escribe un carácter de nueva línea. Si se
  93.  *          lee una línea de un fichero, no tenemos forma de saber si contiene o
  94.  *          no un carácter de nueva línea. Si suponemos que lo hace, y no están
  95.  *          presentes la salida consistirá en una línea de largo. Si suponemos que
  96.  *          fescribirln() elimina este problema.
  97.  */
  98. fescribirln ( FILE *puntero_fichero, char *cadena)
  99. {
  100.    while (*cadena != EOL && *cadena != NULL)
  101.       putc(*cadena++, puntero_fichero);
  102.    putc(NUEVALINEA, puntero_fichero);
  103. }// end fescribirln
  104.  
  105.  
  106. /* NOMBRE: leer_cadena(cadena)
  107.  * FUNCION: Lee una cadena introducida por el usuario y sustituye el retorno de
  108.  *          carro con NULL. Si ocurre final de fichero, leer cadena() retorna el
  109.  *          valor EOF; en otro caso, leer_cadena() retorna el valor NO_ERROR.
  110.  */
  111. leer_cadena(char *cadena)
  112. {
  113.    int letra;
  114.    while((letra = getchar() ) != EOL && letra != EOF)
  115.       *cadena++ = letra;
  116.    *cadena =NULL; /*reemplazar el retorno de carro con NULL */
  117.    return((letra == EOF) ? EOF : NO_ERROR);
  118. }// end leer_cadena
  119.  
  120.  
  121. /* NOMBRE: leerln(cadena)
  122.  * FUNCION: Lee una cadena introducida por el usuario y añade NULL.
  123.  *          El retorno de carro permanece en la cadena. Si ocurre final de
  124.  *          fichero, leerln() retorna el valor EOF; en otro caso, leerln() retorna
  125.  *          el valor NO_ERROR.
  126.  */
  127. leerln( char *cadena)
  128. {
  129.    int letra; /* variable utilizada para verificar EOF */
  130.    while ((letra = getchar() ) != EOL && letra != EOF)
  131.       *cadena++ = letra;
  132.    *cadena = NULL; /*añadir NULL */
  133.    return ((letra == EOF) ? EOF : NO_ERROR);
  134. }// end leerln
  135.  
  136. /* NOMBRE: peticion_respuesta ( peticion, respuesta)
  137.  * FUNCION: Pide al usuario una respuesta válida y retorna una cadena de
  138.  *          caracteres conteniendo la respuesta. Si ocurre un final de fichero,
  139.  *          peticion_respuesta() retorna EOF; en otro caso; peticion_respuesta()
  140.  *          retorna NO_ERROR.
  141.  */
  142. peticion_respuesta ( char *peticion, char *respuesta)
  143. {
  144.    int no_valido = true;   /* FALSE cuando la respuesta es válida */
  145.    int letra;              /* letra leída del usuario para
  146.                               respuesta S o N */
  147.    while ( no_valido)  {
  148.       escribirln( peticion);             /*petición al usuario */
  149.       if (leer_cadena (respuesta) == EOF)
  150.          return(EOF);
  151.       printf("Es %s correcto? (S/N) \n, respuesta);    /*validar */
  152.       if (( letra = leer_car()) == EOF)
  153.          return(EOF);
  154.       if (indice_car ("Ss", letra) != -1)
  155.          no_valido = FALSE;
  156.    }// end while
  157.    return (NO_ERROR);
  158. }// end peticion_respuesta
  159.  
  160.  
  161. /* NOMBRE: obtener_respuesta (respuesta)
  162.  * FUNCION: Obtiene una respuesta del usuario válida y retorna la cadena de
  163.  *          caracteres conteniendo la respuesta. Si ocurre un final de fichero,
  164.  *          obtener_respuesta() retorna el valor EOF; en otro caso obtener_
  165.  *          respueta() retorna NO_ERROR.
  166.  */
  167. obtener_respuesta( char *respuesta)
  168. {
  169.    int no_valido = TRUE;   /* FALSE cuando la respuesta es válida */
  170.    int letra;              /* letra leída del usuario para
  171.                               respuestas S o N */
  172.    while ( no_valido)  {
  173.       if ( leer_cadena (respuesta) == EOF)   /* obtener la respuesta */
  174.          return ( EOF);
  175.       printf ("Es %s correcto? (S/N) \n", respuesta);   /* validar */
  176.       letra = leer_car();
  177.       if (indice_car ( "Ss", letra != -1)
  178.          no_valido = FALSE;
  179.       else
  180.          printf( "Introducir respuesta correcta. \n");
  181.    }// end while
  182.    return(NO_ERROR);
  183. }// end obtener_respuesta
  184.  
  185.  
  186. /* NOMBRE: peticion_ent ( peticion)
  187.  * FUNCION: Pide al usuario que introduzca un valor entero, valida el valor y lo
  188.  *          retorna a la rutina de llamada. Si el usuario continua introduciendo
  189.  *          datos no válidos, la rutina continuará pidiendo al usuario datos
  190.  *          correctos. Si ocurre EOF, peticion_ent() retorna el valor 0.
  191.  */
  192. peticion_ent( char *peticion)
  193. {
  194.    int no_valido = TRUE;   /* FALSE cuando se introduce un entero válido */
  195.    int resultado;          /* valor a retornar a la rutina de llamada */
  196.    char val_ascii[MAX_STRING];   /* dato introducido por el usuario */
  197.    while (no_valido)  {
  198.       puts (peticion);           /* petición al usuario */
  199.       if (leer_cadena (valor_ascii) == EOF)   /* obtener la entrada */
  200.          return (0);
  201.       /* convertir la cadena al valor entero correspondiente */
  202.       if (convertir_ent (val_ascii, &resultado) == NO_ERROR)
  203.          no_valido = FALSE;
  204.       else
  205.          printf ("Dato inválido introducido. Introducir valor entero. \n");
  206.    }// end while
  207.    return( resultado);   /* valor entero válido */
  208. }// end peticion_ent
  209.  
  210. /* NOMBRE: obtener_entero()
  211.  * FUNCION: Retorna nu valor entero válido sin petición del usuario.
  212.  *          Si ocurre un final de fichero, obtener_entero() retorna el valor 0.
  213.  */
  214.       
  215.